/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.ufc.si.tcc.qmusic.util;

import br.ufc.si.tcc.qmusic.automatoImp.AutomatoImp;
import br.ufc.si.tcc.qmusic.interfaces.IAcorde;
import br.ufc.si.tcc.qmusic.model.Nota;
import br.ufc.si.tcc.qmusic.model.Tetrade;
import br.ufc.si.tcc.qmusic.model.Triade;
import br.ufc.si.tcc.qmusic.properties.Properties;
import java.awt.Color;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.sound.midi.*;
import jm.music.data.Note;
import jm.music.data.Part;
import jm.music.data.Phrase;
import jm.music.data.Score;

/**
 *
 * @author Lucas Ismaily
 */
public class UtilQMusic {

    private static int FIRST_NOTE = 32, MAX_KEYS = 64;

    public static void main(String args[]) {

        Nota n = new Nota(Properties.NOTA_DO);
        Nota n1 = new Nota(Properties.NOTA_MI);
        Nota n2 = new Nota(Properties.NOTA_SOL);
        Nota n3 = new Nota(Properties.NOTA_DO);
        Nota n4 = new Nota(Properties.NOTA_MI);
        Nota n5 = new Nota(Properties.NOTA_SOL);
        Nota n6 = new Nota(Properties.NOTA_SI);
        Nota n7 = new Nota(Properties.NOTA_FA_BEMOL);
        Nota n8 = new Nota(Properties.NOTA_LA_BEMOL);
        Nota n9 = new Nota(Properties.NOTA_MI_SUSTENIDO);

        ArrayList<Nota> notas = new ArrayList<Nota>();
        notas.add(n);
        notas.add(n1);
        notas.add(n2);
        notas.add(n3);
        notas.add(n4);
        notas.add(n5);
        notas.add(n6);
        notas.add(n7);
        notas.add(n8);
        notas.add(n9);
        List<IAcorde> triades = new AutomatoImp().reconhecerTriadesTetrades(notas);
        for (IAcorde t : triades) {
            if (!t.getTipo().equalsIgnoreCase(Properties.TRIADE_ENARMONICA) && !t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE_NEM_TETRADE)) {
                System.out.println("" + t.getNotacaoABC());
            }



        }
        for (IAcorde t : triades) {
            if (t instanceof Triade) {
                if (!t.getTipo().equalsIgnoreCase(Properties.TRIADE_ENARMONICA) && !t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE_NEM_TETRADE)) {
                    System.out.println("" + t.getTipo() + " de " + t.getTonica().getNota() + " -->"
                            + "Formada pelas notas [Tônica = " + t.getTonica().getNota() + ", "
                            + "Terça = " + t.getTerca().getNota() + ", "
                            + "Quinta = " + t.getQuinta().getNota() + " ]");
                } else {
                    System.out.println("" + t.getTipo() + " a partir da nota " + t.getTonica().getNota());
                }
            } else if (t instanceof Tetrade) {
                if (!t.getTipo().equalsIgnoreCase(Properties.TETRADE_ENARMONICA) && !t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE_NEM_TETRADE)) {
                    System.out.println("" + t.getTipo() + " de " + t.getTriade().getTonica().getNota() + " -->"
                            + "Formada pelas notas [Tônica = " + t.getTriade().getTonica().getNota() + ", "
                            + "Terça = " + t.getTriade().getTerca().getNota() + ", "
                            + "Quinta = " + t.getTriade().getQuinta().getNota() + ", "
                            + "Sétima = " + t.getSetima().getNota() + "]");
                } else {
                    System.out.println("" + t.getTipo() + " a partir da nota " + t.getTriade().getTonica().getNota());
                }


            }

        }



    }

    /*
     * Método que obtem o intervalo de terca menor (3 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getTercaMenor(Nota n1) {

        if (n1 == null) {
            return null;
        }
        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_MI_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_MI);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_MI_DOBRADO_BEMOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_FA);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_FA_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_SOL);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_SOL_BEMOL);
        }
        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_LA_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_LA_DOBRADO_BEMOL);
        }

        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_SI_DOBRADO_BEMOL);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_DO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_DO_BEMOL);
        }
        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_RE);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_RE_BEMOL);
        }

        return null;

    }

    /*
     * Método que obtem o intervalo de terca maior (4 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getTercaMaior(Nota n1) {

        if (n1 == null) {
            return null;
        }
        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_MI);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_MI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_MI_BEMOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_FA);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_SOL_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_SOL);
        }
        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_LA);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_LA_BEMOL);
        }

        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_DO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_DO);
        }

        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_RE_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_RE);
        }
        return null;
    }

    /*
     * Método que obtem o intervalo de quinta justa (7 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getQuintaJusta(Nota n1) {

        if (n1 == null) {
            return null;
        }
        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_SOL);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_SOL_BEMOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_LA);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_LA_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA_SUSTENIDO);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }
        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_DO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_DO_BEMOL);
        }

        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_RE);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_RE_BEMOL);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_MI);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_MI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_MI_BEMOL);
        }

        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_FA);
        }
        return null;
    }

    /*
     * Método que obtem o intervalo de quinta aumentada (8 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getQuintaAumentada(Nota n1) {
        if (n1 == null) {
            return null;
        }

        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_SOL_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_SOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_LA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_LA);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA_DOBRADO_SUSTENIDO);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_SI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_SI);
        }
        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_DO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_DO);
        }

        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_RE_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_RE);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_MI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_MI_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_MI);
        }

        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO);
        }
        //if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
        //   return new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO);
        // }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }
        return null;
    }

    /*
     * Método que obtem o intervalo de quinta diminuta (6 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getQuintaDiminuta(Nota n1) {

        if (n1 == null) {
            return null;
        }
        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_SOL_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_SOL_DOBRADO_BEMOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_LA_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_LA_DOBRADO_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_SI_DOBRADO_BEMOL);
        }
        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_DO_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_DO_DOBRADO_BEMOL);
        }

        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_RE_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_RE_DOBRADO_BEMOL);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_MI_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_MI);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_MI_DOBRADO_BEMOL);
        }

        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_FA);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_FA_BEMOL);
        }
        return null;
    }

    /*
     * Método que obtem o intervalo de sétima maior (11 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getSetimaMaior(Nota n1) {
        if (n1 == null) {
            return null;
        }
        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_DO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_DO);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO_DOBRADO_SUSTENIDO);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_RE_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_RE);
        }

        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }



        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_FA);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_SOL_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_SOL);
        }
        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_LA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA_DOBRADO_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_LA);
        }
        return null;
    }

    /*
     * Método que obtem o intervalo de sétima menor (10 semitons) com a nota
     * passada por parâmetro
     */
    public static Nota getSetimaMenor(Nota n1) {
        if (n1 == null) {
            return null;
        }
        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            return new Nota(Properties.NOTA_SI_DOBRADO_BEMOL);
        }

        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            return new Nota(Properties.NOTA_DO);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            return new Nota(Properties.NOTA_DO_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            return new Nota(Properties.NOTA_DO_SUSTENIDO);
        }

        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            return new Nota(Properties.NOTA_RE);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_RE_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            return new Nota(Properties.NOTA_RE_BEMOL);
        }

        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            return new Nota(Properties.NOTA_SI_BEMOL);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SI);
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            return new Nota(Properties.NOTA_SI);
        }



        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            return new Nota(Properties.NOTA_FA);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return new Nota(Properties.NOTA_FA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            return new Nota(Properties.NOTA_FA_BEMOL);
        }

        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            return new Nota(Properties.NOTA_SOL);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            return new Nota(Properties.NOTA_SOL_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            return new Nota(Properties.NOTA_SOL_BEMOL);
        }
        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            return new Nota(Properties.NOTA_LA);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            return new Nota(Properties.NOTA_LA_SUSTENIDO);
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            return new Nota(Properties.NOTA_LA_BEMOL);
        }
        return null;
    }

    /*
     * Método que retorna as notas enarmônicas da nota passada por parâmetro
     */
    public static List<Nota> getNotasEnarmonica(Nota n1) {
        if (n1 == null) {
            return null;
        }
        List<Nota> notas = new ArrayList<Nota>();

        //Dó
        if (n1.getNota().equals(Properties.NOTA_DO)) {
            notas.add(new Nota(Properties.NOTA_RE_DOBRADO_BEMOL));
            notas.add(new Nota(Properties.NOTA_SI_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_DO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_RE_BEMOL));
            notas.add(new Nota(Properties.NOTA_SI_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_DO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_SI));
            notas.add(new Nota(Properties.NOTA_LA_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_DO_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_SI_BEMOL));
            notas.add(new Nota(Properties.NOTA_LA_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_DO_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_RE));
            notas.add(new Nota(Properties.NOTA_MI_DOBRADO_BEMOL));
            return notas;
        }


        //Ré
        if (n1.getNota().equals(Properties.NOTA_RE)) {
            notas.add(new Nota(Properties.NOTA_DO_DOBRADO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_MI_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_RE_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_DO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_SI_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_RE_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_MI_BEMOL));
            notas.add(new Nota(Properties.NOTA_FA_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_RE_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_DO));
            notas.add(new Nota(Properties.NOTA_SI_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_RE_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_MI));
            notas.add(new Nota(Properties.NOTA_FA_BEMOL));
            return notas;
        }


        //Mi
        if (n1.getNota().equals(Properties.NOTA_MI)) {
            notas.add(new Nota(Properties.NOTA_RE_DOBRADO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_FA_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_MI_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_FA));
            notas.add(new Nota(Properties.NOTA_SOL_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_MI_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_RE_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_FA_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_MI_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_RE));
            notas.add(new Nota(Properties.NOTA_DO_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_MI_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_FA_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_SOL_BEMOL));
            return notas;
        }


        //Fá
        if (n1.getNota().equals(Properties.NOTA_FA)) {
            notas.add(new Nota(Properties.NOTA_MI_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_SOL_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_FA_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_MI_DOBRADO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_SOL_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_FA_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_MI));
            notas.add(new Nota(Properties.NOTA_RE_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_FA_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_MI_BEMOL));
            notas.add(new Nota(Properties.NOTA_FA_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_FA_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_SOL));
            notas.add(new Nota(Properties.NOTA_LA_DOBRADO_BEMOL));
            return notas;
        }




        //Sol
        if (n1.getNota().equals(Properties.NOTA_SOL)) {
            notas.add(new Nota(Properties.NOTA_LA_DOBRADO_BEMOL));
            notas.add(new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_LA_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_MI_DOBRADO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_FA_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_FA));
            notas.add(new Nota(Properties.NOTA_MI_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SOL_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_LA));
            notas.add(new Nota(Properties.NOTA_SI_DOBRADO_BEMOL));
            return notas;
        }


        //Lá
        if (n1.getNota().equals(Properties.NOTA_LA)) {
            notas.add(new Nota(Properties.NOTA_SOL_DOBRADO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_SI_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_LA_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_DO_DOBRADO_BEMOL));
            notas.add(new Nota(Properties.NOTA_SI_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_LA_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_SOL_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_LA_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_SOL));
            notas.add(new Nota(Properties.NOTA_FA_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_LA_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_SI));
            notas.add(new Nota(Properties.NOTA_DO_BEMOL));
            return notas;
        }

        //Si
        if (n1.getNota().equals(Properties.NOTA_SI)) {
            notas.add(new Nota(Properties.NOTA_DO_BEMOL));
            notas.add(new Nota(Properties.NOTA_LA_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SI_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_DO));
            notas.add(new Nota(Properties.NOTA_RE_DOBRADO_BEMOL));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SI_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_DO_DOBRADO_BEMOL));
            notas.add(new Nota(Properties.NOTA_LA_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SI_DOBRADO_BEMOL)) {
            notas.add(new Nota(Properties.NOTA_LA));
            notas.add(new Nota(Properties.NOTA_SOL_DOBRADO_SUSTENIDO));
            return notas;
        }
        if (n1.getNota().equals(Properties.NOTA_SI_DOBRADO_SUSTENIDO)) {
            notas.add(new Nota(Properties.NOTA_DO_SUSTENIDO));
            notas.add(new Nota(Properties.NOTA_RE_BEMOL));
            return notas;
        }

        return null;
    }

    public static String convertNoteNameToABCNotation(String nota) {


        //Dó
        if (nota.equals(Properties.NOTA_DO)) {
            return Properties.DO;
        }
        if (nota.equals(Properties.NOTA_DO_SUSTENIDO)) {
            return Properties.DO_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_DO_BEMOL)) {
            return Properties.DO_BEMOL;
        }
        //Re
        if (nota.equals(Properties.NOTA_RE)) {
            return Properties.RE;
        }
        if (nota.equals(Properties.NOTA_RE_SUSTENIDO)) {
            return Properties.RE_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_RE_BEMOL)) {
            return Properties.RE_BEMOL;
        }
        //Mi
        if (nota.equals(Properties.NOTA_MI)) {
            return Properties.MI;
        }
        if (nota.equals(Properties.NOTA_MI_SUSTENIDO)) {
            return Properties.MI_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_MI_BEMOL)) {
            return Properties.MI_BEMOL;
        }
        //Fa
        if (nota.equals(Properties.NOTA_FA)) {
            return Properties.FA;
        }
        if (nota.equals(Properties.NOTA_FA_SUSTENIDO)) {
            return Properties.FA_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_FA_BEMOL)) {
            return Properties.FA_BEMOL;
        }
        //Sol
        if (nota.equals(Properties.NOTA_SOL)) {
            return Properties.SOL;
        }
        if (nota.equals(Properties.NOTA_SOL_SUSTENIDO)) {
            return Properties.SOL_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_SOL_BEMOL)) {
            return Properties.SOL_BEMOL;
        }
        //La
        if (nota.equals(Properties.NOTA_LA)) {
            return Properties.LA;
        }
        if (nota.equals(Properties.NOTA_LA_SUSTENIDO)) {
            return Properties.LA_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_LA_BEMOL)) {
            return Properties.LA_BEMOL;
        }
        //Si
        if (nota.equals(Properties.NOTA_SI)) {
            return Properties.SI;
        }
        if (nota.equals(Properties.NOTA_SI_SUSTENIDO)) {
            return Properties.SI_SUSTENIDO;
        }
        if (nota.equals(Properties.NOTA_SI_BEMOL)) {
            return Properties.SI_BEMOL;
        }
        return null;
    }

    public static Nota ConvertNoteToNota(Note note) {
        if (note == null) {
            return null;
        }
        Nota n = new Nota();
        n.setNota(note.getNote());
        n.setDuracao(note.getDuration());
        n.setDeltaTimeInicial(note.getSampleStartTime());
        n.setVolume(note.getPitchValue());
        return n;
    }

    public static Note ConvertNotaToNote(Nota nota) {
        if (nota == null) {
            return null;
        }
        Note n = new Note(nota.getNota());
        n.setDuration(nota.getDuracao());
        n.setSampleStartTime(nota.getDeltaTimeInicial());
        n.setPitch(nota.getVolume());
        return n;
    }

    public static List<Nota> ConvertNotesToNotas(List<Note> notes) {

        if (notes == null || notes.isEmpty()) {
            return null;
        }
        List<Nota> notas = new ArrayList<Nota>();
        for (Note n : notes) {
            notas.add(ConvertNoteToNota(n));
        }
        return notas;
    }

    public static List<Nota> ConvertNotasToNotacaCompleta(List<Nota> notas) {

        if (notas == null || notas.isEmpty()) {
            return null;
        }
        List<Nota> notasConvertidas = new ArrayList<Nota>();
        for (Nota n : notas) {
            if (n.mudarNotacaoABCToCompleto()) {
                notasConvertidas.add(n);
            }

        }
        return notasConvertidas;

    }

    public static List<Note> ConvertNotasToNotes(List<Nota> notas) {
        List<Note> notes = new ArrayList<Note>();
        for (Nota n : notas) {
            notes.add(ConvertNotaToNote(n));
        }
        return notes;
    }

    public static Nota getIntervalo(Nota n, int semitons) {

        List<Nota> notas = Properties.SequenciaNotasCromaticas();
        int pos = -1;
        for (int i = 0; i < notas.size(); i++) {
            if (notas.get(i).getNota().equalsIgnoreCase(n.getNota())) {
                pos = i;
                break;
            }
        }
        if (pos == -1) {
            return null;
        }
        return notas.get((pos + semitons) % 12);
    }

    private static boolean verificarInsert(ArrayList vetor, int element) {

        for (int i = 0; i < vetor.size(); i++) {
            if (vetor.get(i).equals(new Integer(element))) {
                return false;
            }
        }
        return true;

    }

    public static ArrayList<Integer> getInstrumetsJmusic(Score score) {
        if (score == null) {
            return null;
        }
        Part[] parts = score.getPartArray();
        ArrayList<Integer> instrumentos = new ArrayList<Integer>();
        for (int i = 0; i < parts.length; i++) {
            if (verificarInsert(instrumentos, parts[i].getInstrument())) {
                instrumentos.add(parts[i].getInstrument());
                System.out.println("Istrumento da música " + parts[i].getInstrument());
            }
        }
        return instrumentos;
    }

    public static ArrayList<Note> getNotesByInstrumetAndFile(File file, int programa) {

        if (file == null) {
            return null;
        }
        ArrayList<Note> notes = new ArrayList<Note>();
        MidiData midiData = new MidiData();
        if (midiData.initialize(file)) {

            if (midiData.initializeTrack()) {
                MidiChannel[] c = midiData.getSynthensizer().getChannels();
                boolean fechar = false;
                for (int i = 0; i < c.length; i++) {
                    if (fechar) {
                        return notes;
                    }
                    if (c[i].getProgram() == programa) {
                        fechar = true;
                        while (!midiData.isTrackEnd()) {
                            if (midiData.getEventCommand()
                                    == ShortMessage.NOTE_ON) {
                                // assegura que nota válida está no intervalo das teclas
                                Note n = new Note(midiData.getNote(), midiData.getVolume());
                                //System.out.println(midiData.getNote());
                                notes.add(n);
                                //System.out.println(n.getNote());
                            }
                            midiData.goNextEvent();
                        }
                    }
                }
            }
        }
        return notes;
    }

    public static ArrayList<Instrument> getInstrumetsMusica(Instrument instrumentosPossiveis[], ArrayList<Integer> instrumentosDaMusica) {
        if (instrumentosPossiveis == null || instrumentosPossiveis.length == 0) {
            return null;
        }
        if (instrumentosDaMusica == null || instrumentosDaMusica.isEmpty()) {
            return null;
        }

        for (int i = 0; i < instrumentosPossiveis.length; i++) {
            System.out.println("" + instrumentosPossiveis[i]);
        }

        ArrayList<Instrument> instrumentos = new ArrayList<Instrument>();
        for (Integer inst : instrumentosDaMusica) {
            for (int k = 0; k < instrumentosPossiveis.length; k++) {
                Integer program = new Integer(instrumentosPossiveis[k].getPatch().getProgram());
                if (inst.equals(program)) {
                    instrumentos.add(instrumentosPossiveis[k]);
                }
            }
        }
        return instrumentos;
    }

    public static Instrument getInstrumetByName(ArrayList<Instrument> instrumentosPossiveis, String name) {
        if (instrumentosPossiveis == null || instrumentosPossiveis.isEmpty()) {
            return null;
        }
        for (Instrument inst : instrumentosPossiveis) {
            String nameComp = inst.getName();
            if (nameComp.equals(name)) {
                return inst;
            }
        }

        return null;
    }

    public static boolean podeInserir(Nota n, ArrayList<Nota> notas) {

        for (Nota nComp : notas) {
            if (nComp.getNota().equalsIgnoreCase(n.getNota()) && nComp.getDeltaTimeInicial() == n.getDeltaTimeInicial()) {
                return false;
            }
        }
        return true;
    }

    public static ArrayList<Nota> eliminarDecalagem(ArrayList<Nota> notas) {
        Collections.sort(notas);
        ArrayList<Nota> novasNotas = new ArrayList<Nota>();
        for (Nota n : notas) {
            if (podeInserir(n, novasNotas)) {
                novasNotas.add(n);
            }
        }

        return novasNotas;
    }

    public static boolean temTetradeValida(List<Tetrade> tetrades) {
        for (Tetrade te : tetrades) {
            if (!te.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TETRADE)
                    && !te.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE_NEM_TETRADE)) {
                return true;
            }
        }
        return false;
    }

    public static boolean temTriadeValida(List<Triade> triade) {
        for (Triade t : triade) {
            if (!t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE)
                    && !t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE_NEM_TETRADE)) {
                return true;
            }
        }
        return false;
    }

    public static boolean temAcordeValido(List<IAcorde> acordes) {
        for (IAcorde t : acordes) {
            if (!t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE)
                    && !t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TETRADE)
                    && !t.getTipo().equalsIgnoreCase(Properties.NAO_FORMOU_TRIADE_NEM_TETRADE)) {
                return true;
            }
        }
        return false;

    }
}
